/**
 * 地图工具函数
 */

/**
 * 使用高德地图API进行地理编码（将地址转换为经纬度）
 * @param {string} address 地址文本，如"北京市朝阳区建国路89号"
 * @param {string} city 城市名称（可选），如"北京"
 * @returns {Promise<Array>} 返回经纬度数组 [longitude, latitude]
 */
export function geocodeAddress(address, city = '') {
  return new Promise((resolve, reject) => {
    // 检查地址是否有效
    if (!address || typeof address !== 'string' || address.trim() === '') {
      console.warn('地址为空，使用默认坐标')
      return resolve([116.397428, 39.90923]) // 北京默认坐标
    }
    
    // 检查是否是纯数字地址
    if (/^\d+$/.test(address)) {
      console.warn('检测到纯数字地址，使用默认坐标')
      return resolve([116.397428, 39.90923]) // 北京默认坐标
    }
    
    // 检查是否是纯数字+市的地址
    if (/^\d+市$/.test(address)) {
      console.warn('检测到无效城市名称，使用默认坐标')
      return resolve([116.397428, 39.90923]) // 北京默认坐标
    }
    
    // 特殊处理内蒙古地区
    if (address === '乌海市' || address.includes('乌海')) {
      console.log('检测到乌海市，使用乌海市坐标')
      return resolve([106.794249, 39.655388]) // 乌海市坐标
    }
    
    // 检查高德地图API是否加载
    if (typeof AMap === 'undefined') {
      console.error('高德地图API未加载，使用默认坐标')
      
      // 常见城市的默认坐标
      const cityCoordinates = {
        '北京': [116.397428, 39.90923],
        '北京市': [116.397428, 39.90923],
        '上海': [121.473701, 31.230416],
        '上海市': [121.473701, 31.230416],
        '广州': [113.264385, 23.129112],
        '广州市': [113.264385, 23.129112],
        '深圳': [114.057868, 22.543099],
        '深圳市': [114.057868, 22.543099],
        '杭州': [120.155070, 30.274084],
        '杭州市': [120.155070, 30.274084],
        '南京': [118.796877, 32.060255],
        '南京市': [118.796877, 32.060255],
        '武汉': [114.305393, 30.593099],
        '武汉市': [114.305393, 30.593099],
        '成都': [104.065735, 30.659462],
        '成都市': [104.065735, 30.659462],
        '重庆': [106.551557, 29.563009],
        '重庆市': [106.551557, 29.563009],
        '西安': [108.948024, 34.263161],
        '西安市': [108.948024, 34.263161],
        '天津': [117.200983, 39.084158],
        '天津市': [117.200983, 39.084158],
        '青岛': [120.382639, 36.067082],
        '青岛市': [120.382639, 36.067082],
        '大连': [121.614682, 38.914003],
        '大连市': [121.614682, 38.914003],
        '苏州': [120.585316, 31.298886],
        '苏州市': [120.585316, 31.298886],
        '厦门': [118.089425, 24.479833],
        '厦门市': [118.089425, 24.479833],
        // 内蒙古地区城市坐标
        '呼和浩特': [111.749181, 40.842585],
        '呼和浩特市': [111.749181, 40.842585],
        '包头': [109.840347, 40.658116],
        '包头市': [109.840347, 40.658116],
        '乌海': [106.794249, 39.655388],
        '乌海市': [106.794249, 39.655388],
        '赤峰': [118.886856, 42.257817],
        '赤峰市': [118.886856, 42.257817],
        '通辽': [122.243444, 43.652890],
        '通辽市': [122.243444, 43.652890],
        '鄂尔多斯': [109.781327, 39.608266],
        '鄂尔多斯市': [109.781327, 39.608266],
        '呼伦贝尔': [119.765744, 49.211574],
        '呼伦贝尔市': [119.765744, 49.211574],
        '巴彦淖尔': [107.387657, 40.743213],
        '巴彦淖尔市': [107.387657, 40.743213],
        '乌兰察布': [113.132585, 40.994785],
        '乌兰察布市': [113.132585, 40.994785]
      }
      
      // 检查是否有该城市的默认坐标
      if (address && cityCoordinates[address]) {
        console.log(`使用${address}的默认坐标:`, cityCoordinates[address])
        return resolve(cityCoordinates[address])
      }
      
      // 如果没有找到匹配的城市坐标，使用北京的坐标
      return resolve([116.397428, 39.90923])
    }

    // 处理仅包含城市名称的简单地址
    const simpleCityName = address.replace(/市$/, '').trim()
    if (simpleCityName.length <= 4) {
      console.log(`处理简单城市名称: ${simpleCityName}`)
      city = simpleCityName // 将简单城市名称作为city参数
    }

    // 创建地理编码实例
    AMap.plugin('AMap.Geocoder', () => {
      const geocoder = new AMap.Geocoder({
        city: city, // 指定查询的城市名
        radius: 1000 // 查找范围，单位：米
      })
      
      // 地理编码
      geocoder.getLocation(address, (status, result) => {
        if (status === 'complete' && result.info === 'OK' && result.geocodes.length > 0) {
          // 解析经纬度
          const location = result.geocodes[0].location
          console.log(`地理编码成功: ${address} => [${location.lng}, ${location.lat}]`)
          resolve([location.lng, location.lat])
        } else {
          console.warn(`地理编码失败: ${address}, 状态: ${status}, 信息: ${result.info}`)
          
          // 特殊处理内蒙古地区
          if (address.includes('乌海') || city.includes('乌海')) {
            console.log('地理编码失败，使用乌海市默认坐标')
            return resolve([106.794249, 39.655388]) // 乌海市坐标
          }
          
          // 尝试使用城市中心点坐标
          if (city && city !== address) {
            console.log(`尝试获取城市 ${city} 的中心点坐标`)
            geocoder.getLocation(city, (cityStatus, cityResult) => {
              if (cityStatus === 'complete' && cityResult.info === 'OK' && cityResult.geocodes.length > 0) {
                const cityLocation = cityResult.geocodes[0].location
                console.log(`使用城市中心点坐标: ${city} => [${cityLocation.lng}, ${cityLocation.lat}]`)
                resolve([cityLocation.lng, cityLocation.lat])
              } else {
                // 如果城市也解析失败，使用默认坐标
                console.warn(`城市中心点获取失败，使用默认坐标`)
                resolve([116.397428, 39.90923]) // 北京默认坐标
              }
            })
          } else {
            // 没有城市信息，使用默认坐标
            console.warn(`无城市信息，使用默认坐标`)
            resolve([116.397428, 39.90923]) // 北京默认坐标
          }
        }
      })
    })
  })
}

/**
 * 使用高德地图API进行批量地理编码
 * @param {Array<Object>} addressList 地址列表，每个对象包含address和city属性
 * @returns {Promise<Array>} 返回经纬度数组的列表
 */
export function batchGeocodeAddresses(addressList) {
  const promises = addressList.map(item => 
    geocodeAddress(item.address, item.city)
      .catch(error => {
        console.error(`地址 "${item.address}" 地理编码失败:`, error)
        return null // 返回null表示该地址编码失败
      })
  )
  
  return Promise.all(promises)
}

/**
 * 使用高德地图API进行路线规划
 * @param {Array} origin 起点经纬度 [longitude, latitude]
 * @param {Array} destination 终点经纬度 [longitude, latitude]
 * @returns {Promise<Object>} 返回路线规划结果，包含路径点
 */
export function planRoute(origin, destination) {
  return new Promise((resolve, reject) => {
    // 检查高德地图API是否已加载
    if (typeof AMap === 'undefined') {
      console.error('高德地图API未加载，使用模拟路径')
      // 使用模拟路径
      const simulatedPath = generateSimulatedPath(origin, destination, 5)
      return resolve({
        status: 'error',
        info: '高德地图API未加载',
        path: simulatedPath
      })
    }

    // 创建驾车路线规划实例
    AMap.plugin('AMap.Driving', () => {
      const driving = new AMap.Driving({
        policy: AMap.DrivingPolicy.LEAST_TIME, // 最快捷模式
        ferry: 0,  // 不使用轮渡
        map: null  // 不在地图上显示
      })
      
      // 规划路线
      driving.search(
        new AMap.LngLat(origin[0], origin[1]), // 起点
        new AMap.LngLat(destination[0], destination[1]), // 终点
        (status, result) => {
          if (status === 'complete' && result.routes && result.routes.length > 0) {
            // 提取路径点
            const route = result.routes[0]
            const path = route.steps.reduce((acc, step) => {
              return acc.concat(step.path)
            }, [])
            
            // 转换为经纬度数组
            const pathArray = path.map(point => [point.lng, point.lat])
            
            console.log('路线规划成功，获取到路径点:', pathArray.length)
            resolve({
              status: 'complete',
              info: 'OK',
              path: pathArray,
              distance: route.distance,
              time: route.time
            })
          } else {
            console.warn('路线规划失败，使用模拟路径')
            // 路线规划失败，使用模拟路径
            const simulatedPath = generateSimulatedPath(origin, destination, 5)
            resolve({
              status: 'error',
              info: '路线规划失败',
              path: simulatedPath
            })
          }
        }
      )
    })
  })
}

/**
 * 检查坐标是否在中国大陆范围内
 * @param {number} lng 经度
 * @param {number} lat 纬度
 * @returns {boolean} 是否在中国大陆范围内
 */
function isInChinaMainland(lng, lat) {
  // 中国大陆大致范围
  const minLng = 73.0;  // 最西边
  const maxLng = 135.0; // 最东边
  const minLat = 18.0;  // 最南边
  const maxLat = 53.0;  // 最北边
  
  // 基本范围检查
  if (lng < minLng || lng > maxLng || lat < minLat || lat > maxLat) {
    return false;
  }
  
  // 避开东海和南海的主要海域
  // 东海区域 (粗略范围)
  if (lng > 123.0 && lng < 130.0 && lat > 25.0 && lat < 33.0) {
    return false;
  }
  
  // 南海区域 (粗略范围)
  if (lng > 110.0 && lng < 120.0 && lat > 15.0 && lat < 22.0) {
    return false;
  }
  
  return true;
}

/**
 * 调整坐标点使其位于中国大陆范围内
 * @param {Array} point 经纬度点 [longitude, latitude]
 * @param {Array} reference 参考点 [longitude, latitude]
 * @returns {Array} 调整后的经纬度点
 */
function adjustPointToMainland(point, reference) {
  if (isInChinaMainland(point[0], point[1])) {
    return point; // 如果已经在范围内，不做调整
  }
  
  // 向参考点方向调整
  const direction = [
    reference[0] - point[0],
    reference[1] - point[1]
  ];
  
  // 计算方向向量长度
  const length = Math.sqrt(direction[0] * direction[0] + direction[1] * direction[1]);
  
  // 归一化方向向量
  const normalizedDir = [
    direction[0] / length,
    direction[1] / length
  ];
  
  // 逐步向参考点移动，直到找到在大陆范围内的点
  let adjustedPoint = [...point];
  let steps = 0;
  const maxSteps = 20; // 最大尝试次数
  const stepSize = 0.5; // 每次移动的距离
  
  while (!isInChinaMainland(adjustedPoint[0], adjustedPoint[1]) && steps < maxSteps) {
    adjustedPoint[0] += normalizedDir[0] * stepSize;
    adjustedPoint[1] += normalizedDir[1] * stepSize;
    steps++;
  }
  
  // 如果调整后仍然不在范围内，则取起点和终点的中点
  if (!isInChinaMainland(adjustedPoint[0], adjustedPoint[1])) {
    return [
      (point[0] + reference[0]) / 2,
      (point[1] + reference[1]) / 2
    ];
  }
  
  return adjustedPoint;
}

/**
 * 生成两点之间的模拟路径点
 * @param {Array} start 起点经纬度 [longitude, latitude]
 * @param {Array} end 终点经纬度 [longitude, latitude]
 * @param {number} pointCount 路径点数量
 * @returns {Array<Array>} 返回路径点数组
 */
export function generateSimulatedPath(start, end, pointCount = 5) {
  // 确保起点和终点有效
  if (!start || !end || !Array.isArray(start) || !Array.isArray(end) || 
      start.length !== 2 || end.length !== 2) {
    console.error('起点或终点坐标无效，无法生成路径')
    return [
      [116.397428, 39.90923], // 北京
      [121.473701, 31.230416]  // 上海
    ]
  }
  
  // 计算两点之间的距离
  const distance = Math.sqrt(
    Math.pow(end[0] - start[0], 2) + 
    Math.pow(end[1] - start[1], 2)
  )
  
  // 根据距离调整点数量，距离越大点越多
  const adjustedPointCount = Math.max(
    5, 
    Math.min(10, Math.ceil(distance * 50))
  )
  
  // 确保点数量至少为5
  pointCount = Math.max(5, pointCount, adjustedPointCount)
  
  const path = []
  
  // 添加起点
  path.push(start)
  
  // 计算两点之间的差值
  const lngDiff = end[0] - start[0]
  const latDiff = end[1] - start[1]
  
  // 计算直线方向
  const angle = Math.atan2(latDiff, lngDiff)
  
  // 确定是否为南北方向路线
  const isNorthSouth = Math.abs(latDiff) > Math.abs(lngDiff)
  
  // 生成中间点
  for (let i = 1; i < pointCount - 1; i++) {
    const ratio = i / pointCount
    
    // 基本点位置（直线插值）
    const baseLng = start[0] + lngDiff * ratio
    const baseLat = start[1] + latDiff * ratio
    
    // 减小偏移量，最大偏移为距离的3%
    // 对于南北方向的路线，进一步减小经度方向的偏移，避免偏移到海上
    const maxOffsetRatio = isNorthSouth ? 0.01 : 0.02
    const maxOffset = distance * maxOffsetRatio
    
    // 使用余弦函数创建平滑的弯曲效果
    // 中间点的偏移最大，两端的偏移较小
    const curveRatio = Math.cos(ratio * Math.PI * 2 - Math.PI) * 0.5 + 0.5
    
    // 计算垂直于直线的偏移向量
    // 对于南北方向的路线，经度偏移再减半
    const perpLng = -Math.sin(angle) * maxOffset * curveRatio * (isNorthSouth ? 0.3 : 1)
    const perpLat = Math.cos(angle) * maxOffset * curveRatio
    
    // 添加非常小的随机偏移，使路径看起来更自然
    const randomLng = (Math.random() - 0.5) * 0.0005 * distance
    const randomLat = (Math.random() - 0.5) * 0.0005 * distance
    
    // 计算偏移后的点
    const lng = baseLng + perpLng + randomLng
    const lat = baseLat + perpLat + randomLat
    
    // 检查点是否在中国大陆范围内，如果不在则调整
    const point = [lng, lat]
    const midPoint = [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2]
    const adjustedPoint = adjustPointToMainland(point, midPoint)
    
    path.push(adjustedPoint)
  }
  
  // 添加终点
  path.push(end)
  
  return path
}

/**
 * 使用高德地图API获取两点间的实际路径
 * @param {Array} start 起点经纬度 [longitude, latitude]
 * @param {Array} end 终点经纬度 [longitude, latitude]
 * @returns {Promise<Array>} 返回路径点数组
 */
export async function getRoutePath(start, end) {
  try {
    // 先尝试使用高德地图的路线规划
    const routeResult = await planRoute(start, end)
    
    if (routeResult.status === 'complete' && routeResult.path && routeResult.path.length > 0) {
      // 使用高德地图规划的路径
      return routeResult.path
    } else {
      // 如果规划失败，使用模拟路径
      console.warn('路线规划失败，使用模拟路径')
      return generateSimulatedPath(start, end, 5)
    }
  } catch (error) {
    console.error('获取路径失败:', error)
    // 出错时使用模拟路径
    return generateSimulatedPath(start, end, 5)
  }
} 